﻿#define _CRT_SECURE_NO_WARNINGS

//57.
//给你一个 m x n 大小的矩阵 grid ，由若干正整数组成。
//执行下述操作，直到 grid 变为空矩阵：
//从每一行删除值最大的元素。如果存在多个这样的值，删除其中任何一个。
//将删除元素中的最大值与答案相加。
//注意 每执行一次操作，矩阵中列的数据就会减 1 。
//返回执行上述操作后的答案。
int deleteGreatestValue(int** grid, int gridSize, int* gridColSize) {
    // 记录答案
    int sum = 0;
    int n = *gridColSize;//记录每一行的列数
    int m = gridSize;//记录行数
    int i;
    int j;
    int max = 0;//记录每一次的最大值
    int index = n;//记录比较的次数
    while (index--)
    {
        max = 0;
        for (i = 0; i < m; i++)
        {
            int x = i, y = 0;
            int temp = grid[x][0];
            for (j = 1; j < n; j++)
            {
                if (grid[i][j] > temp)
                {
                    temp = grid[i][j];
                    x = i;
                    y = j;
                }
            }
            max = max > temp ? max : temp;
            grid[x][y] = -1;
        }
        sum = sum + max;
    }
    return sum;
}

//方法二：先排序在依次找每一列最大值
//定义快速排序
int  sort(const void* e1, const void* e2) {
    return *(int*)e1 - *(int*)e2;
}
int deleteGreatestValue(int** grid, int gridSize, int* gridColSize) {
    int i;
    int ans = 0; //记录答案
    //对数组每一行进行排序
    for (i = 0; i < gridSize; i++)
    {   //参数:数组起始位置;数组个数;每个数的大小;升序(降序)排序
        qsort(grid[i], *gridColSize, sizeof(int), sort);
    }
    int j;
    //初始化最大列下边
    int y = *gridColSize - 1;
    int max = 0;
    while (y >= 0)
    {
        max = grid[0][y];
        for (j = 1; j < gridSize; j++)
        {
            if (grid[j][y] > max)
            {
                max = grid[j][y];
            }
        }
        ans += max;
        y--;
    }
    return ans;
}

//58.
//给你一个 m x n 的整数网格 accounts ，其中 accounts[i][j] 是第 i​​​​​​​​​​​​ 位客户在第 j 家银行托管的资产数量。返回最富有客户所拥有的 资产总量 。
//客户的 资产总量 就是他们在各家银行托管的资产数量之和。最富有客户就是 资产总量 最大的客户。
int maximumWealth(int** accounts, int accountsSize, int* accountsColSize) {
    int i;
    int j;
    int max = 0;
    for (i = 0; i < accountsSize; i++)
    {
        int sum = 0;
        for (j = 0; j < *accountsColSize; j++)
        {
            sum = sum + accounts[i][j];
        }
        max = max > sum ? max : sum;
    }
    return max;
}

//59.
//给你一个整数 num ，返回 num 中能整除 num 的数位的数目。
//如果满足 nums% val == 0 ，则认为整数 val 可以整除 nums 。
int countDigits(int num) {
    int temp = num;
    int ans = 0; //记录答案
    //获取每一位数
    while (temp)
    {
        int ge = temp % 10;
        temp /= 10;
        if (num % ge == 0)
            ans++;
    }
    return ans;
}

//60.
//给你一个数组 nums ，数组中有 2n 个元素，按[x1, x2, ..., xn, y1, y2, ..., yn] 的格式排列。
//请你将数组按[x1, y1, x2, y2, ..., xn, yn] 格式重新排列，返回重排后的数组。
int* shuffle(int* nums, int numsSize, int n, int* returnSize) {

    int* ans = (int*)malloc(sizeof(int) * 2 * n);
    int left = 0;
    int right = n;

    int i = 0;
    while (left < n && right < 2 * n) {
        if (i % 2 == 0) {
            ans[i] = nums[left++];
        }
        else {
            ans[i] = nums[right++];
        }
        i++;
    }
    ans[i] = nums[right];

    *returnSize = 2 * n;
    return ans;
}
//方法二：简化代码
int* shuffle(int* nums, int numsSize, int n, int* returnSize) {
    int* ans = (int*)malloc(sizeof(int) * 2 * n);
    int i;
    for (i = 0; i < n; i++)
    {
        ans[i * 2] = nums[i];
        ans[i * 2 + 1] = nums[n + i];
    }

    *returnSize = 2 * n;
    return ans;
}